home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / lfslib / descMap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-26  |  8.6 KB  |  342 lines
  1. /* 
  2.  * descMap.c --
  3.  *
  4.  *    Routines for accessing LFS file systems desc map datastuctures from
  5.  *    a user level program.
  6.  *
  7.  * Copyright 1990 Regents of the University of California
  8.  * Permission to use, copy, modify, and distribute this
  9.  * software and its documentation for any purpose and without
  10.  * fee is hereby granted, provided that the above copyright
  11.  * notice appear in all copies.  The University of California
  12.  * makes no representations about the suitability of this
  13.  * software for any purpose.  It is provided "as is" without
  14.  * express or implied warranty.
  15.  */
  16.  
  17. #ifndef lint
  18. static char rcsid[] = "$Header: /sprite/lib/forms/RCS/proto.c,v 1.3 90/01/12 12:03:36 douglis Exp $ SPRITE (Berkeley)";
  19. #endif /* not lint */
  20.  
  21. #include "lfslib.h"
  22. #include "lfslibInt.h"
  23. #ifdef _HAS_PROTOTYPES
  24. #include <varargs.h>
  25. #include <sys/types.h>
  26. #endif /* _HAS_PROTOTYPES */
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <sys/file.h>
  30. #include <unistd.h>
  31. #include <bstring.h>
  32. #include <sys/time.h>
  33.  
  34. /*
  35.  *----------------------------------------------------------------------
  36.  *
  37.  * LfsGetNewFileNumber --
  38.  *
  39.  *    Allocate an used file number for a newly created file or directory.
  40.  *
  41.  * Results:
  42.  *    An error if could not find a free file descriptor.
  43.  *    SUCCESS if a file number can be allocate.
  44.  *    FAILURE if all available file numbers are taken.
  45.  *    
  46.  * Side effects:
  47.  *    None.
  48.  *
  49.  *----------------------------------------------------------------------
  50.  */
  51.  
  52. ReturnStatus
  53. LfsGetNewFileNumber(lfsPtr, dirFileNumber, fileNumberPtr)
  54.     Lfs         *lfsPtr;    /* FS to allocate the file 
  55.                  * descriptor out of. */
  56.     int     dirFileNumber;    /* File number of the directory that
  57.              * the file is in.  -1 means that
  58.              * this file descriptor is being
  59.              * allocated for a directory. */
  60.     int    *fileNumberPtr; /* Place to return the file number allocated. */
  61. {
  62.     LfsDescMap          *mapPtr = &(lfsPtr->descMap);
  63.     register LfsDescMapEntry   *entryPtr;
  64.     register int maxNumDesc, startDesc, i;
  65.     Boolean    found = FALSE;
  66.     static    int dirSeed = 0;
  67.  
  68.     maxNumDesc = lfsPtr->superBlock.descMap.maxDesc;
  69.     if (dirFileNumber == -1) {
  70.     if (dirSeed == 0) {
  71.         dirSeed = time(0);
  72.     } 
  73.         /*
  74.          * Search linearly from a random starting descriptor.
  75.          */
  76.         startDesc = ((dirSeed * 1103515245 + 12345) & 0x7fffffff) %
  77.                         maxNumDesc;
  78.     dirSeed++;
  79.     } else {
  80.     startDesc = dirFileNumber;
  81.     }
  82.     entryPtr = LfsGetDescMapEntry(lfsPtr, startDesc);
  83.     i = startDesc;
  84.     do { 
  85.     if (!(entryPtr->flags & LFS_DESC_MAP_ALLOCED)) {
  86.         found = TRUE;
  87.         break;
  88.     }
  89.     i++;
  90.         if (i == maxNumDesc) {
  91.         i = 0;
  92.     }
  93.     entryPtr = LfsGetDescMapEntry(lfsPtr, i);
  94.    } while (i != startDesc);
  95.     if (!found) {    
  96.         panic( "Out of file descriptors.\n");
  97.     return FAILURE;
  98.     }
  99.     mapPtr->checkPoint.numAllocDesc++;
  100.     entryPtr->blockAddress = FSDM_NIL_INDEX;
  101.     entryPtr->flags = LFS_DESC_MAP_ALLOCED;
  102.     *fileNumberPtr = i;
  103.     LfsDescMapEntryModified(lfsPtr, i);
  104.     return SUCCESS;
  105. }
  106.  
  107.  
  108. /*
  109.  *----------------------------------------------------------------------
  110.  *
  111.  * LoadDescMap --
  112.  *
  113.  *    Load the descriptor map array into memory.
  114.  *
  115.  * Results:
  116.  *    TRUE if array can not be loaded. FALSE otherwise.
  117.  *
  118.  * Side effects:
  119.  *    None.
  120.  *
  121.  *----------------------------------------------------------------------
  122.  */
  123. Boolean
  124. LfsLoadDescMap(lfsPtr, checkPointSize, checkPointPtr)
  125.     Lfs    *lfsPtr;        /* File system. */
  126.     int    checkPointSize; /* Size of the checkpoint region. */
  127.     char *checkPointPtr; /* The checkpoint region. */
  128. {
  129.     LfsStableMemCheckPoint *cpPtr;
  130.     LfsStableMemParams  *smemParamsPtr;
  131.    Boolean         ret = FALSE;
  132.  
  133.     if (checkPointSize < sizeof(LfsDescMapCheckPoint)) {
  134.     fprintf(stderr,"%s: Bad DescMap checkpoint size %d\n", 
  135.             lfsPtr->deviceName, checkPointSize);
  136.     return TRUE;
  137.     }
  138.     smemParamsPtr = &(lfsPtr->superBlock.descMap.stableMem);
  139.  
  140.  
  141.     bcopy(checkPointPtr, (char *) &lfsPtr->descMap.checkPoint, 
  142.         sizeof(LfsDescMapCheckPoint));
  143.  
  144.  
  145.      cpPtr = (LfsStableMemCheckPoint *)
  146.             (checkPointPtr + sizeof(LfsDescMapCheckPoint));
  147.  
  148.     lfsPtr->descMap.smemPtr =  LfsLoadStableMem(lfsPtr, smemParamsPtr, cpPtr);
  149.  
  150.     return ret;
  151.  
  152. }
  153.  
  154.  
  155. /*
  156.  *----------------------------------------------------------------------
  157.  *
  158.  * DescMapCheckpoint --
  159.  *
  160.  *    Routine to handle checkpointing of the descriptor map data.
  161.  *
  162.  * Results:
  163.  *    TRUE if more data needs to be written, FALSE if this module is
  164.  *    checkpointed.
  165.  *
  166.  * Side effects:
  167.  *    Many
  168.  *
  169.  *----------------------------------------------------------------------
  170.  */
  171.  
  172. Boolean
  173. LfsDescMapCheckpoint(segPtr, checkPointPtr, checkPointSizePtr)
  174.     LfsSeg *segPtr;        /* Segment containing data for checkpoint. */
  175.     char   *checkPointPtr;      /* Buffer to write checkpoint data. */
  176.     int       *checkPointSizePtr;  /* Bytes added to the checkpoint area.*/
  177. {
  178.  
  179.     Lfs              *lfsPtr = segPtr->lfsPtr;
  180.     LfsDescMap          *mapPtr = &(lfsPtr->descMap);
  181.     LfsDescMapCheckPoint *cp = (LfsDescMapCheckPoint *) checkPointPtr;
  182.     int        size, dataSize;
  183.     Boolean    full;
  184.  
  185.     *cp = mapPtr->checkPoint;
  186.     size = sizeof(LfsDescMapCheckPoint);
  187.     dataSize = 0;
  188.     full = LfsStableMemCheckpoint(segPtr, checkPointPtr + size, 
  189.             &dataSize, segPtr->lfsPtr->descMap.smemPtr);
  190.     if (!full) { 
  191.     (*checkPointSizePtr) = dataSize + size;
  192.     }
  193.     return full;
  194.  
  195. }
  196.  
  197. /*
  198.  *----------------------------------------------------------------------
  199.  *
  200.  * DescWriteDone --
  201.  *
  202.  *    Routine to handle finishing of a checkpoint.
  203.  *
  204.  * Results:
  205.  *    None
  206.  *
  207.  * Side effects:
  208.  *    Many
  209.  *
  210.  *----------------------------------------------------------------------
  211.  */
  212.  
  213. void
  214. LfsDescMapWriteDone(segPtr, flags)
  215.     LfsSeg *segPtr;        /* Segment containing data for checkpoint. */
  216.     int       flags;        /* Flags for checkpoint */
  217. {
  218.     Lfs              *lfsPtr = segPtr->lfsPtr;
  219.     LfsDescMap          *mapPtr = &(lfsPtr->descMap);
  220.  
  221.     LfsStableMemWriteDone(segPtr, flags, mapPtr->smemPtr);
  222.     return;
  223.  
  224. }
  225.  
  226.  
  227. /*
  228.  *----------------------------------------------------------------------
  229.  *
  230.  * LfsDescMapGetVersion --
  231.  *
  232.  *    Return the descriptor map truncate version for the specified
  233.  *    file.
  234.  *
  235.  * Results:
  236.  *    SUCCESS if the entry is resident in the descriptor map.
  237.  *    FS_FILE_NOT_FOUND if the file is not allocated.
  238.  *    
  239.  * Side effects:
  240.  *    None.
  241.  *
  242.  *----------------------------------------------------------------------
  243.  */
  244.  
  245. ReturnStatus
  246. LfsDescMapGetVersion(lfsPtr, fileNumber, versionNumPtr)
  247.     Lfs      *lfsPtr;    /* File system of descriptor. */
  248.     int      fileNumber;   /* File number of descriptor. */ 
  249.     unsigned short  *versionNumPtr; /* Area to return version number in.*/
  250. {
  251.     LfsDescMapEntry   *entryPtr;
  252.     ReturnStatus      status = SUCCESS;
  253.  
  254.     entryPtr = LfsGetDescMapEntry(lfsPtr, fileNumber);
  255.  
  256.     if (!(entryPtr->flags & LFS_DESC_MAP_ALLOCED)) {
  257.     status = FS_FILE_NOT_FOUND;
  258.     } else { 
  259.     *versionNumPtr = entryPtr->truncVersion;
  260.     }
  261.     return status;
  262.  
  263. }
  264.  
  265.  
  266. /*
  267.  *----------------------------------------------------------------------
  268.  *
  269.  * LfsDescMapGetDiskAddr --
  270.  *
  271.  *    Return the disk address of the specified descriptor.
  272.  *
  273.  * Results:
  274.  *    SUCCESS if the entry is resident in the descriptor map.
  275.  *    FS_FILE_NOT_FOUND if the file is not allocated.
  276.  *    GEN_INVALID_ARG if the fileNumber is not available in the map.
  277.  *    
  278.  * Side effects:
  279.  *    None.
  280.  *
  281.  *----------------------------------------------------------------------
  282.  */
  283.  
  284. ReturnStatus
  285. LfsDescMapGetDiskAddr(lfsPtr, fileNumber, diskAddrPtr)
  286.     Lfs      *lfsPtr;    /* File system of descriptor. */
  287.     int      fileNumber;   /* File number of descriptor. */ 
  288.     int  *diskAddrPtr; /* Current disk address.*/
  289. {
  290.     LfsDescMapEntry   *entryPtr;
  291.     ReturnStatus      status = SUCCESS;
  292.  
  293.  
  294.     entryPtr = LfsGetDescMapEntry(lfsPtr, fileNumber);
  295.  
  296.     if (!(entryPtr->flags & LFS_DESC_MAP_ALLOCED)) {
  297.     status = FS_FILE_NOT_FOUND;
  298.     }
  299.     *diskAddrPtr = entryPtr->blockAddress;
  300.     return status;
  301.  
  302. }
  303.  
  304. /*
  305.  *----------------------------------------------------------------------
  306.  *
  307.  * LfsDescMapSetDiskAddr --
  308.  *
  309.  *    Set the disk address for the specified descriptor.
  310.  *
  311.  * Results:
  312.  *    SUCCESS if the entry is resident in the descriptor map.
  313.  *    FAILURE if the fileNumber is not available in the map.
  314.  *    
  315.  * Side effects:
  316.  *    None.
  317.  *
  318.  *----------------------------------------------------------------------
  319.  */
  320.  
  321. ReturnStatus
  322. LfsDescMapSetDiskAddr(lfsPtr, fileNumber, diskAddr)
  323.     Lfs      *lfsPtr;    /* File system of descriptor. */
  324.     int      fileNumber;   /* File number of descriptor. */ 
  325.     int diskAddr; /* New disk address.*/
  326. {
  327.     LfsDescMapEntry   *entryPtr;
  328.     ReturnStatus    status = SUCCESS;
  329.  
  330.  
  331.     entryPtr = LfsGetDescMapEntry(lfsPtr, fileNumber);
  332.     if (!(entryPtr->flags & LFS_DESC_MAP_ALLOCED)) {
  333.     status = FAILURE;
  334.     } else { 
  335.     entryPtr->blockAddress = diskAddr;
  336.     LfsDescMapEntryModified(lfsPtr, fileNumber);
  337.     }
  338.     return status;
  339.  
  340. }
  341.  
  342.